// 解题思路：
// 题目要求：从 n 个人里面选 k 个人，要求能力值乘积最大（能力值有正有负），要求这 k 个人，挨着的两个人的位置差不超过 d
// 能力值：-50 <= a[i] <= 50, 1 <= n <= 50, 1 <= k <= 10, 1 <= d <= 50

// 这是一道经典的动态规划题目
// 状态表示：
// f[i][j] 表示从 i 个人里面挑 j 个人，第 i 个人必选，能力值的最大乘积， j <= i
// g[i][j] 表示从 i 个人里面挑 j 个人，第 i 个人必选，能力值的最小乘积， j <= i

// 初始化：
// f[i][1] = g[i][1] = arr[i]
// f[i][j] = INF, g[i][j] = -INF, i > 1, j > 1
// 原因是能力值有负数，如果能力值最后算出来是负数，要想得到它，就需要让最大能力初始化为负无穷，最小能力初始化为正无穷

// 状态转移方程：
// arr[i] > 0: f[i][j] = Math.max(f[i][j], f[l][j - 1] * arr[i]), l 包含于 [max(i - d, 1), i - 1]
// g[i][j] = Math.min(g[i][j], g[l][j - 1])

// arr[i] < 0: f[i][j] = Math.max(f[i][j], g[l][j - 1] * arr[i])
// g[i][j] = Math.min(g[i][j], f[l][j - 1] * arr[i])

// arr[i] == 0, f[i][j] = g[i][j] = 0

// 填表顺序：从上往下，每一行从左往右

// 返回值：
// 因为从 i 个人中选 k 个人，第 i 个人是必选的，选第 i 个人不一定能力最大，因此要从[f[k][k], f[n][k]] 中找最大值

import java.util.Scanner;

public class SelectionGame {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);

        int n = in.nextInt();

        int[] arr = new int[n + 1];
        for(int i = 1; i <= n; i++){
            arr[i] = in.nextInt();
        }

        int k = in.nextInt();
        int d = in.nextInt();

        long[][] f = new long[n + 1][n + 1];
        long[][] g = new long[n + 1][n + 1];

        long INF = 0x3f3f3f3f3f3f3f3fL;

        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= i; j++){
                if(j == 1){
                    f[i][j] = g[i][j] = arr[i];
                }else{
                    f[i][j] = -INF;
                    g[i][j] = INF;
                }
            }
        }

        for(int i = 2; i <= n; i++){
            for(int j = 2; j <= i; j++){
                for(int l = Math.max(1, i - d); l < i; l++){
                    if(arr[i] > 0){
                        f[i][j] = Math.max(f[i][j], f[l][j - 1] * arr[i]);
                        g[i][j] = Math.min(g[i][j], g[l][j - 1] * arr[i]);
                    }else if(arr[i] < 0){
                        f[i][j] = Math.max(f[i][j], g[l][j - 1] * arr[i]);
                        g[i][j] = Math.min(g[i][j], f[l][j - 1] * arr[i]);
                    }else{
                        f[i][j] = g[i][j] = 0;
                        break;
                    }
                }
            }
        }

        long max = -INF;
        for(int i = k; i <= n; i++){
            max = Math.max(max, f[i][k]);
        }

        System.out.println(max);
    }
}
